home *** CD-ROM | disk | FTP | other *** search
/ Popular Request / By Popular Request (Arsenal Computer)(SysOptics Distribution System).ISO / amiga4 / vidprint.lha / VidPrint / src / ilbm2prt.c next >
C/C++ Source or Header  |  1993-12-06  |  7KB  |  248 lines
  1. /* ilbm2prt
  2.  * This program converts a ilbm-file to a series of rgb-files that can be fed
  3.  * separately with "copy <name> to par:" into a Mitsubishi Videoprinter
  4.  *
  5.  * Source-code and executable are ⌐'93 by
  6.  *           Stephan Feinen
  7.  *           Im Steinfeld 1
  8.  *           52076 Aachen
  9.  *           Germany
  10.  *
  11.  * Please send comments, criticism and suggestions to:
  12.  *           feinen@pool.informatik.rwth-aachen.de
  13.  *
  14. */
  15.  
  16. #define VERSION "1.2"
  17. #include <stdio.h>
  18. #include <fcntl.h>
  19. #include <sys/file.h>
  20. #define RowBytes(cols)  ( ( ( (int)(cols) + 15 ) >> 4 ) << 1 )
  21. #define mskNone                 0
  22. #define mskHasMask              1
  23. #define mskHasTransparentColor  2
  24. #define mskLasso                3
  25.  
  26. #define cmpNone                 0
  27. #define cmpByteRun1             1
  28. #define ALLOCROW( cols ) ((pixel*) malloc( cols * sizeof(pixel) ))
  29.  
  30. struct BitMapHeader
  31. {
  32.     unsigned short w, h;
  33.     short x, y;
  34.     unsigned char nPlanes, masking, compression, pad1;
  35.     unsigned short transparentColor;
  36.     unsigned char xAspect, yAspect;
  37.     short pageWidth, pageHeight;
  38. };
  39.  
  40.  
  41. typedef struct
  42.     {
  43.     unsigned char r, g, b;
  44.     } pixel;
  45.  
  46. char   version[25]="$VER: 1.2 (05.12.93)";
  47. char   vers[10]=VERSION;
  48.  
  49.  
  50. pixel *pixelrow;
  51.  
  52. struct BitMapHeader ilbmheader;
  53. unsigned char   form[5],header[11];
  54. unsigned char  *ubp,*bp;
  55. unsigned char *runbuf;
  56. unsigned char   *Rrow;
  57. unsigned char   *Brow;
  58. unsigned char   *Grow;
  59. unsigned int    byte;
  60. int     totbytes,row;
  61. int col,j,plane;
  62. long    bmsize,formsize;
  63. unsigned char *body = 0;
  64. unsigned long body_chunk_size;
  65. FILE *fp;
  66. int     fd1,fd2,fd3;
  67. char tempname[40];
  68.  
  69. void Usage()
  70. {
  71. fprintf(stderr,"Usage: ilbm2prt ILBMFILE/A BASENAME/A\n");
  72. fprintf(stderr,"ILBMFILE must be a 24-bit ILBM\n");
  73. fprintf(stderr,"BASENAME will be expanded to BASENAME.red, BASENAME.grn, BASENAME.blu\n");
  74. }
  75.  
  76. main( argc, argv )
  77. int argc;
  78. char **argv;
  79. {
  80.  printf("ilbm2prt %s ⌐1993 Stephan Feinen\n",vers);
  81.  if (argc != 3){
  82.    Usage();
  83.    exit(1);
  84.    }
  85.  
  86.  if (!(fp = fopen(argv[1],"r"))){
  87.    fprintf(stderr,"Open of '%s' for reading failed.\n",argv[1]);
  88.    exit(20);
  89.    }
  90.  puts("Opened source");
  91.  strcpy(tempname,argv[2]);
  92.  strcat(tempname, ".red");
  93.  printf("tempname:%s\n",tempname);
  94.  if ((fd1 = creat(tempname,0660)) < 0) {
  95.    fprintf(stderr,"Open of '%s' for writing red-part failed.\n",tempname);
  96.    exit(20);
  97.    }
  98.  puts("Opened red-file");
  99.  strcpy(tempname,argv[2]);
  100.  strcat(tempname, ".grn");
  101.  if ((fd2 = creat(tempname,0660)) < 0) {
  102.    fprintf(stderr,"Open of '%s' for writing green-part  failed.\n",tempname);
  103.    exit(20);
  104.    }
  105.  puts("Opened green-file");
  106.  strcpy(tempname,argv[2]);
  107.  strcat(tempname, ".blu");
  108.  if ((fd3 = creat(tempname,0660)) < 0) {
  109.    fprintf(stderr,"Open of '%s' for writing blue-part failed.\n",tempname);
  110.    exit(20);
  111.    }
  112.  puts("Opened blue-file");
  113.  
  114.  fread(form,4,1,fp);            /* FORM */
  115.  if (strcmp(form,"FORM") != NULL) {
  116.    fprintf(stderr,"'%s' is not an IFF file. Exiting.\n",argv[1]);
  117.    fclose(fp);
  118.    close(fd1);
  119.    close(fd2);
  120.    close(fd3);
  121.    exit(20);
  122.    }
  123.  fread(&formsize,4,1,fp);       /* Size of whole form -4 */
  124.  printf("%s ",form);
  125.  fread(form,4,1,fp);            /* ILBM */
  126.  printf("%s: (%d bytes) ",form,formsize);
  127.  fread(form,4,1,fp);            /* BMHD */
  128.  fread(&bmsize,4,1,fp);         /* size of BMHD */
  129.  fread(&ilbmheader,20,1,fp);
  130.  printf("(%dx%d) (%d planes) (Compression %s)\n",ilbmheader.w,ilbmheader.h,ilbmheader.nPlanes, ilbmheader.compression == cmpByteRun1 ? "On" : "Off");
  131.  if (ilbmheader.nPlanes != 24) {
  132.    fprintf(stderr,"Only IFF ILBM's of 24 bit planes are supported.\n");
  133.    fclose(fp);
  134.    close(fd1);
  135.    close(fd2);
  136.    close(fd3);
  137.    exit(20);
  138.    }
  139.  
  140.  fread(form,4,1,fp);            /* BODY (ANNO sometimes) */
  141.  
  142.  while ((strcmp(form,"BODY") != 0))     /* Find the damn thing */
  143.    fread(form,4,1,fp);
  144.         
  145.  fread(&body_chunk_size,4,1,fp);
  146.  
  147.  pixelrow = ALLOCROW(ilbmheader.w);
  148.  body = (unsigned char*) malloc(body_chunk_size);
  149.  runbuf = (unsigned char*) malloc(RowBytes(ilbmheader.w));
  150.  Rrow = (unsigned char*) malloc(ilbmheader.w);
  151.  Grow = (unsigned char*) malloc(ilbmheader.w);
  152.  Brow = (unsigned char*) malloc(ilbmheader.w);
  153.  if (body == NULL || pixelrow == NULL || runbuf == NULL ||
  154.    Rrow == NULL || Grow == NULL || Brow == NULL) {
  155.    fprintf(stderr,"Unable to allocate all the memory I need...\n");
  156.    fclose(fp);
  157.    close(fd1);
  158.    close(fd2);
  159.    close(fd3);
  160.    exit(20);
  161.    }
  162.  header[0]=27;
  163.  header[1]=83;
  164.  header[2]=48;
  165.  header[3]=(ilbmheader.h) / 256;
  166.  header[4]=(ilbmheader.h) % 256;
  167.  header[5]=75;
  168.  bp = body;
  169.  
  170.         /* Read in the body of the ilbm */
  171.  fread(body, body_chunk_size, 1, fp); 
  172.  puts("sources read\n");
  173.  write(fd1,header,6); 
  174.  for (row = 0; row < (int)ilbmheader.h; row++ ) {
  175.  
  176.         /* There are kind of colormappish */
  177. /*   Only needed if planes != 24 */
  178.    for (col = 0; col < 640 ; col++ )
  179.      Rrow[col] = Grow[col] = Brow[col] = 0;
  180.  
  181.    for (plane = 0; plane < (int)ilbmheader.nPlanes; plane++) {
  182.      switch (ilbmheader.compression) {
  183.  
  184.        case 0:
  185.               ubp = bp;
  186.               bp += RowBytes(640);
  187.               break;
  188.        case 1:
  189.               ubp = runbuf;
  190.               totbytes = RowBytes(640);
  191.               do {
  192.                 byte = *bp++;
  193.                 if ( byte <= 127 )
  194.                   for ( j = byte, totbytes -= j + 1; j >= 0; j--) {
  195.                     *ubp++ = *bp++;
  196.                     }
  197.                 else if ( byte != 128 )
  198.                   for (j = 256 - byte, totbytes -= j + 1, byte = *bp++; j >= 0; j--) {
  199.                     *ubp++ = byte;
  200.                     }
  201.                 } while ( totbytes > 0 );
  202.               ubp = runbuf;
  203.               break;
  204.        }
  205.  
  206.        /* Break raw row buffer up into separate rgb values */
  207.        /* In order to understand this a little better, it might help */
  208.        /* to know that the pixel values in an ILBM appear to be stored */
  209.        /* bit reversed. Hence all the logical bitwise juju. */
  210.      if ( plane < 8){
  211.        for ( col = 0; col < 640; col++ )
  212.          {
  213.          if ( ubp[col >> 3] & ( 128 >> ( col & 7 ) ) )
  214.            Rrow[col] |= 1 << plane;
  215.          }
  216.        }
  217.      else if ( plane > 15 ) { /* blue */
  218.        for ( col = 0; col < 640; col++ )
  219.          {
  220.          if ( ubp[col >> 3] & ( 128 >> ( col & 7 ) ) )
  221.            Brow[col] |= 1 << (plane-16);
  222.          }
  223.        }
  224.      else { /* green */
  225.        for ( col = 0; col < 640; col++ )
  226.          {
  227.          if ( ubp[col >> 3] & ( 128 >> ( col & 7 ) ) )
  228.            Grow[col] |= 1 << (plane-8);
  229.          }
  230.        }
  231.      }
  232.       /* Write out an entire row of pixel interleaved data */
  233.      write(fd1, Rrow, 640);
  234.      write(fd2, Grow, 640);
  235.      write(fd3, Brow, 640);
  236.    }
  237.  free(Rrow);            /* Fly! Be Free!! */
  238.  free(Grow);
  239.  free(Brow);
  240.  free(runbuf);
  241.  free(body);
  242.  fclose(fp);
  243.  close(fd1);
  244.  close(fd2);
  245.  close(fd3);
  246.  exit(0);
  247. }
  248.